package test;

public class Math_Float
{
	/*******************************************************************************
	 * Software: Math_Float.java
	 * Version:  1.0
	 * Date:     Jan 5, 2010 9:32:44 PM
	 * License:  none specified yet.
	 *
	 * PURPOSE:
	 * REQUIREMENTS WHAT ELSE IS NEEDED:
	 * TODO:
	 * FEATURES:
	 *******************************************************************************/
	public Math_Float()
	{
	}

	public static void main(String [] args)
	{
		stuff();
	}
	
	public static void convert()
	{
		byte b = Byte.parseByte("123");
		short s = Short.parseShort("123");
		int i = Integer.parseInt("123");
		long l = Long.parseLong("123");
		float f = Float.parseFloat("123.4");
		double d = Double.parseDouble("123.4e10");		
	}

	static void stuff()
	{
		/**
		 * Rundungsfehler
			Prinzipiell sollten Anweisungen wie 1.1 – 0.1 immer 1.0 ergeben,
			jedoch treten interne Rundungsfehler bei der Darstellung auf und
			lassen das Ergebnis von Berechnung zu Berechnung immer ungenauer
			werden. Ein besonders ungünstiger Fehler trat 1994 beim
			Pentium-Prozessor im Divisionsalgorithmus Radix-4 SRT auf,
			ohne dass der Programmierer der Schuldige war.
			Ein fehlerhafter Prozessor liefert hier 256, obwohl laut Rechenregel das Ergebnis 0 sein muss. Laut Intel sollte für einen normalen Benutzer (Spieler, Softwareentwickler, Surfer?) der Fehler nur alle 27 000 Jahre auftauchen. Glück für die meisten. Eine Studie von IBM errechnete eine Fehlerhäufigkeit von einmal in 24 Tagen. Alles in allem hat Intel die CPUs zurückgenommen, über 400 Millionen US-Dollar verloren und spät den Kopf gerade noch aus der Schlinge gezogen.
			Die meisten Rundungsfehler resultieren aber daher, dass endliche Dezimalbrüche im Rechner als Näherungswerte für periodische Binärbrüche repräsentiert werden müssen. 0,1 entspricht einer periodischen Mantisse im IEEE-Format.
		 */
		double x, y, z;
		x = 4195835.0;
		y = 3145727.0;
		z = x - (x/y) * y;
		/**
		 * 
		In Java lassen sich Zuweisungen mit numerischen Operatoren kombinieren. Für einen Operator # im Ausdruck a = a # (b) kürzt der Verbundoperator den Ausdruck zu a #= b ab. So addiert a += 2 zur Variable a 2 hinzu, und der Rückgabewert ist die um 2 erhöhte Variable a.
		Besondere Obacht sollten wir auf die automatische Klammerung geben. Bei einem Ausdruck wie a *= 3 + 5 gilt a = a * (3 + 5) und nicht selbstverständliche die Punkt-vor-Strich-Regelung a = a * 3 + 5.
		Falls es sich bei der rechten Seite um einen komplexeren Ausdruck handelt, wird dieser nur einmal ausgewertet. Dies ist wichtig bei Methodenaufrufen, die Nebenwirkungen besitzen, etwa Zustände wie einen Zähler verändern.
		 */

		/**
		 * Im ersten Fall bekommen wir den Wert 3 und im zweiten Fall 2. Der erste Fall überrascht nicht. Denn a = ++a erhöht den Wert 2 um 1, und anschließend wird 3 der Variablen a zugewiesen. Bei b ist es raffinierter. Der Wert von b ist 2, und dieser Wert wird intern vermerkt. Anschließend erhöht b++ die Variable b. Doch die Zuweisung setzt b auf den gemerkten Wert, der 2 war. Also ist b = 2.
		 */
		int a, b;
		a = 2; 
		a = ++a;      // a = 3 
		b = 2; 
		b = b++;      // b = 2
		
		double celsius, fahrenheit = 12;
		celsius = ( fahrenheit - 32 ) * 5 / 9;
		
		/**
		 * The abstract class <code>Number</code> is the superclass of classes
		 * <code>BigDecimal</code>, <code>BigInteger</code>,
		 * <code>Byte</code>, <code>Double</code>, <code>Float</code>,
		 * <code>Integer</code>, <code>Long</code>, and <code>Short</code>.
		 * <p>
		 * Subclasses of <code>Number</code> must provide methods to convert 
		 * the represented numeric value to <code>byte</code>, <code>double</code>,
		 * <code>float</code>, <code>int</code>, <code>long</code>, and
		 * <code>short</code>.
		 *
		 * @author	Lee Boynton
		 * @author	Arthur van Hoff
		 * @version 1.29, 12/19/03
		 * @see     java.lang.Byte
		 * @see     java.lang.Double
		 * @see     java.lang.Float
		 * @see     java.lang.Integer
		 * @see     java.lang.Long
		 * @see     java.lang.Short
		 * @since   JDK1.0
		 */
		Number number = 123.33;
		/**
		 * "number"= Double  (id=15)
		 * MAX_VALUE= 1.7976931348623157E308
		 */
		
		System.out.println( java.lang.Math.sin(0.528740) ); // Funktionsaufruf sin() als Ausdruck
		/**
		 * Etwas wackelig ist der Begriff Ausdrucksanweisung bei Funktionen, die keine Rückgabe liefern. println() ist so eine Funktion.
		 * Sie gibt nichts zurück (void) und ist daher auch kein Ausdruck. Daher führt Folgendes zu einem Compilerfehler:
		 */
		// System.out.println( System.out.println() ); // Compilerfehler!
		
		/** operantive ausdrücke **/
		int i = 12, j;
		j = i + 2;
		
		/**
		 * Bei Ausdrücken mit unterschiedlichen numerischen Datentypen, etwa int und double,
		 * bringt der Compiler vor der Anwendung der Operation alle Operanden auf den umfassenderen Typ.
		 * Vor der Auswertung von 1 + 2.0 wird somit die Ganzzahl 1 zum double konvertiert und dann
		 * die Addition vorgenommen – das Ergebnis ist auch vom Typ double.
		 * Das nennt sich numerische Umwandlung (engl. numeric promotion).
		 * Bei byte und short gilt die Sonderregelung, dass sie vorher auf int konvertiert werden.
		 * [http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#26917]
		 * (Auch im Java-Bytecode gibt es keine arithmetischen Operationen auf byte, short und char.)
		 * Anschließend wird die Operation ausgeführt, und der Ergebnistyp entspricht dem umfassenderen Typ.

		 * Der binäre Operator »/« bildet den Quotienten aus Dividend und Divisor.
		 * Auf der linken Seite steht der Dividend und auf der rechten der Divisor.
		 * Die Division ist für Ganzzahlen und für Fließkommazahlen definiert.
		 * Bei der Ganzzahldivision wird zu null hin gerundet, und das Ergebnis ist keine Fließkommazahl,
		 * sodass 1/3 das Ergebnis 0 ergibt und nicht 0,333... Den Datentyp des Ergebnisses bestimmen
		 * die Operanden und nicht der Operator. Soll das Ergebnis vom Typ double sein, muss ein Operand ebenfalls double sein. **/
		System.out.println( 1.0 / 3 );	// 0.3333333333333333 
		System.out.println( 1 / 3.0 );	// 0.3333333333333333 
		System.out.println( 1 / 3 );	// 0
		
		/**
		 * Schon die Schulmathematik lehrte uns, dass die Division durch null nicht erlaubt ist.
		 * Führen wir in Java eine Ganzzahldivision mit dem Divisor 0 durch, so bestraft uns Java mit einer ArithmeticException.
		 **/
		// System.out.println( 3 / 0 );	// Exception in thread "main" java.lang.ArithmeticException: / by zero
		/**
		 * Bei Fließkommazahlen liefert eine Division durch 0 keine Ausnahme,
		 * sondern +/– unendlich und bei 0.0/0.0 den Sonderwert NaN (mehr dazu in Kapitel 5, »Mathematisches«).
		 * Ein NaN steht für Not a Number (auch schon manchmal »Unzahl« genannt) und wird vom Prozessor erzeugt,
		 * falls er eine mathematische Operation wie die Division durch null nicht durchführen kann.
		 */
		System.out.println( 3.0 / 0 );	// Infinity
		System.out.println( 0.0 / 0.0 );	// NaN
		
		/** modulo operator leifert den nachkomma-rest einer division **/
		System.out.println( 9 % 2 );	// 1 == ein rest
		System.out.println( 9 % 3 );	// 0 == kein rest bei 9/3 == 3 geht glatt auf.
		System.out.println( 9.0 % 3.0 );	// 0.0 == kein rest bei 9/3 == 3 geht glatt auf.
		System.out.println( 12. % 2.5 );	// 2.0
		
		/** Die Division und der Restwert richten sich in Java nach einer einfachen Formel: (int)(a/b)*b + (a%b) = a. **/
		double var_a = 12;
		double var_b = 2.5;
		System.out.println( (var_a/var_b)*var_b + (var_a%var_b) );

		System.out.println( "+5 % +3 = " + (+5 % +3) ); // 2 
		System.out.println( "+5 / +3 = " + (+5 / +3) ); // 1 
		
		System.out.println( "+5 % –3 = " + (+5 % -3) ); // 2 
		System.out.println( "+5 / –3 = " + (+5 / -3) ); // –1 
		
		System.out.println( "-5 % +3 = " + (-5 % +3) ); // –2 
		System.out.println( "-5 / +3 = " + (-5 / +3) ); // –1 
		
		System.out.println( "-5 % –3 = " + (-5 % -3) ); // –2 
		System.out.println( "-5 / –3 = " + (-5 / -3) ); // 1

		/** Exponent to the power of **/
		System.out.println( Math.pow(2,8) ); // 2^8 = 256
		
//		double exp(double d) 	Returns the base of the natural logarithms, e, to the power of the argument.
//		double log(double d) 	Returns the natural logarithm of the argument.
//		double pow(double base, double exponent) 	Returns the value of the first argument raised to the power of the second argument.
//		double sqrt(double d) 	Returns the square root of the argument. 		
	}
}